<!DOCTYPE html>
<html lang="zh-Hans">

<head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge, chrome=1" />
    <meta name="viewport"
        content="width=device-width, initial-scale=1.0,maximum-scale=1,minimum-scale=1,user-scalable=no">

    <link rel="stylesheet" href="./css/index.css" />
</head>

<body>
    <h1>JavaScript 集合</h1>

    <h2>参考链接</h2>
    
    <ul>
        <li><a target="_blank"
            href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Map">JavaScript
            Map</a></li>

        <li><a target="_blank"
                href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Set">JavaScript
                Set</a></li>

    </ul>

    <h2>Map</h2>
    <p>Map 对象保存键值对，并且能够记住键的原始插入顺序。任何值(对象或者原始值) 都可以作为一个键或一个值。</p>


    <ul>
        <li>
            <strong>属性</strong>

            <ul>
                <li><strong>Map.prototype.size</strong> 返回Map对象的键/值对的数量。</li>
            </ul>
        </li>
        <li>
            <strong>方法</strong>

            <ul>
                <li><strong>Map.prototype.clear()</strong> 移除Map对象的所有键/值对 。</li>
                <li><strong>Map.prototype.delete(key)</strong> 如果 Map 对象中存在该元素，则移除它并返回 true；否则如果该元素不存在则返回 false。随后调用 Map.prototype.has(key) 将返回 false 。</li>
                <li><strong>Map.prototype.entries()</strong> 返回一个新的 Iterator 对象，它按插入顺序包含了Map对象中每个元素的 [key, value] 数组。</li>
                <li><strong>Map.prototype.forEach(callbackFn[, thisArg])</strong> 按插入顺序，为 Map对象里的每一键值对调用一次callbackFn函数。如果为forEach提供了thisArg，它将在每次回调中作为this值。</li>
                <li><strong>Map.prototype.get(key)</strong> 返回键对应的值，如果不存在，则返回undefined。</li>
                <li><strong>Map.prototype.has(key)</strong> 返回一个布尔值，表示Map实例是否包含键对应的值。</li>
                <li><strong>Map.prototype.keys()</strong> 返回一个新的 Iterator对象， 它按插入顺序包含了Map对象中每个元素的键 。</li>
                <li><strong>Map.prototype.set(key, value)</strong> 设置Map对象中键的值。返回该Map对象。</li>
                <li><strong>Map.prototype.values()</strong> 返回一个新的Iterator对象，它按插入顺序包含了Map对象中每个元素的值 。</li>
            </ul>
        </li>
    </ul>

    <h3>部分示例</h3>
    <h4>使用 Map 对象</h4>
    <pre>
let myMap = new Map();

let keyObj = {};
let keyFunc = function() {};
let keyString = 'a string';
    
// 添加键
myMap.set(keyString, "和键'a string'关联的值");
myMap.set(keyObj, "和键keyObj关联的值");
myMap.set(keyFunc, "和键keyFunc关联的值");
    
myMap.size; // 3
    
// 读取值
myMap.get(keyString);    // "和键'a string'关联的值"
myMap.get(keyObj);       // "和键keyObj关联的值"
myMap.get(keyFunc);      // "和键keyFunc关联的值"
    
myMap.get('a string');   // "和键'a string'关联的值"
                            // 因为keyString === 'a string'
myMap.get({});           // undefined, 因为keyObj !== {}
myMap.get(function() {}); // undefined, 因为keyFunc !== function () {}
    </pre>

    <h4>使用 for..of 方法迭代 Map</h4>
    <pre>
let myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (let [key, value] of myMap) {
    console.log(key + " = " + value);
}
// 将会显示两个log。一个是"0 = zero"另一个是"1 = one"

for (let key of myMap.keys()) {
    console.log(key);
}
// 将会显示两个log。 一个是 "0" 另一个是 "1"

for (let value of myMap.values()) {
    console.log(value);
}
// 将会显示两个log。 一个是 "zero" 另一个是 "one"

for (let [key, value] of myMap.entries()) {
    console.log(key + " = " + value);
}
// 将会显示两个log。 一个是 "0 = zero" 另一个是 "1 = one"
    </pre>

    <h4>使用 forEach() 方法迭代 Map</h4>

    <pre>
myMap.forEach(function(value, key) {
    console.log(key + " = " + value);
})
// 将会显示两个logs。 一个是 "0 = zero" 另一个是 "1 = one"
    </pre>

    <h2>Set</h2>

    <p>Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。</p>

    <ul>
        <li>
            <strong>属性</strong>

            <ul>
                <li><strong>Set.prototype.size</strong> 返回Set对象的值的个数。</li>
            </ul>
        </li>
        <li>
            <strong>方法</strong>

            <ul>
                <li><strong>Set.prototype.add(value)</strong> 在Set对象尾部添加一个元素。返回该Set对象。</li>
                <li><strong>Set.prototype.clear()</strong> 移除Set对象内的所有元素。</li>
                <li><strong>Set.prototype.delete(value)</strong> 移除Set的中与这个值相等的元素，返回Set.prototype.has(value)在这个操作前会返回的值（即如果该元素存在，返回true，否则返回false）。Set.prototype.has(value)在此后会返回false。</li>
                <li><strong>Set.prototype.entries()</strong> 返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值的[value, value]数组。为了使这个方法和Map对象保持相似， 每个值的键和值相等。</li>
                <li><strong>Set.prototype.forEach(callbackFn[, thisArg])</strong> 按照插入顺序，为Set对象中的每一个值调用一次callBackFn。如果提供了thisArg参数，回调中的this会是这个参数。</li>
                <li><strong>Set.prototype.has(value)</strong> 返回一个布尔值，表示该值在Set中存在与否。</li>
                <li><strong>Set.prototype.keys()</strong> 与values()方法相同，返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值。</li>
                <li><strong>Set.prototype.values()</strong> 返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值。</li>
                <li><strong>Set.prototype.add(value)</strong> 在Set对象尾部添加一个元素。返回该Set对象。</li>
            </ul>
        </li>
    </ul>

    <h3>部分示例</h3>

    <h4>使用Set对象</h4>

    <pre>
let mySet = new Set();

mySet.add(1); // Set [ 1 ]
mySet.add(5); // Set [ 1, 5 ]
mySet.add(5); // Set [ 1, 5 ]
mySet.add("some text"); // Set [ 1, 5, "some text" ]
let o = {a: 1, b: 2};
mySet.add(o);

mySet.add({a: 1, b: 2}); // o 指向的是不同的对象，所以没问题

mySet.has(1); // true
mySet.has(3); // false
mySet.has(5);              // true
mySet.has(Math.sqrt(25));  // true
mySet.has("Some Text".toLowerCase()); // true
mySet.has(o); // true

mySet.size; // 5

mySet.delete(5);  // true,  从set中移除5
mySet.has(5);     // false, 5已经被移除

mySet.size; // 4, 刚刚移除一个值
console.log(mySet); // Set {1, "some text", Object {a: 1, b: 2}, Object {a: 1, b: 2}}
    </pre>

    <h4>迭代Set</h4>

    <pre>
// 迭代整个set
// 按顺序输出：1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2}
for (let item of mySet) console.log(item);

// 按顺序输出：1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2} 
for (let item of mySet.keys()) console.log(item);
    
// 按顺序输出：1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2} 
for (let item of mySet.values()) console.log(item);

// 按顺序输出：1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2} 
//(键与值相等)
for (let [key, value] of mySet.entries()) console.log(key);

// 使用 Array.from 转换Set为Array 
var myArr = Array.from(mySet); // [1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2}]

// 如果在HTML文档中工作，也可以：
mySet.add(document.body);
mySet.has(document.querySelector("body")); // true

// Set 和 Array互换
mySet2 = new Set([1,2,3,4]);
mySet2.size; // 4
[...mySet2]; // [1,2,3,4]

// 可以通过如下代码模拟求交集 
let intersection = new Set([...set1].filter(x => set2.has(x)));

// 可以通过如下代码模拟求差集
let difference = new Set([...set1].filter(x => !set2.has(x)));

// 用forEach迭代
mySet.forEach(function(value) {
    console.log(value);
});

// 1
// 2
// 3
// 4
    </pre>

</body>

</html>